home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / managers / FocusManager.as < prev    next >
Text File  |  2014-03-27  |  32KB  |  961 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.InteractiveObject;
  6.    import flash.display.Sprite;
  7.    import flash.events.Event;
  8.    import flash.events.FocusEvent;
  9.    import flash.events.KeyboardEvent;
  10.    import flash.events.MouseEvent;
  11.    import flash.system.Capabilities;
  12.    import flash.text.TextField;
  13.    import flash.ui.Keyboard;
  14.    import mx.core.FlexSprite;
  15.    import mx.core.IButton;
  16.    import mx.core.IChildList;
  17.    import mx.core.IRawChildrenContainer;
  18.    import mx.core.IUIComponent;
  19.    import mx.core.mx_internal;
  20.    import mx.events.FlexEvent;
  21.    
  22.    use namespace mx_internal;
  23.    
  24.    public class FocusManager implements IFocusManager
  25.    {
  26.       
  27.       mx_internal static const VERSION:String = "3.0.0.0";
  28.        
  29.       
  30.       private var focusableObjects:Array;
  31.       
  32.       private var _showFocusIndicator:Boolean = false;
  33.       
  34.       private var defButton:IButton;
  35.       
  36.       private var _form:IFocusManagerContainer;
  37.       
  38.       private var focusableCandidates:Array;
  39.       
  40.       private var LARGE_TAB_INDEX:int = 99999;
  41.       
  42.       private var browserFocusComponent:InteractiveObject;
  43.       
  44.       private var activated:Boolean = false;
  45.       
  46.       private var _defaultButton:IButton;
  47.       
  48.       private var calculateCandidates:Boolean = true;
  49.       
  50.       private var _focusPane:Sprite;
  51.       
  52.       private var lastFocus:IFocusManagerComponent;
  53.       
  54.       private var _defaultButtonEnabled:Boolean = true;
  55.       
  56.       public var browserMode:Boolean;
  57.       
  58.       private var lastAction:String;
  59.       
  60.       public function FocusManager(param1:IFocusManagerContainer, param2:Boolean = false)
  61.       {
  62.          super();
  63.          browserMode = Capabilities.playerType == "ActiveX" && !param2;
  64.          param1.focusManager = this;
  65.          _form = param1;
  66.          focusableObjects = [];
  67.          focusPane = new FlexSprite();
  68.          focusPane.name = "focusPane";
  69.          addFocusables(DisplayObject(param1));
  70.          param1.addEventListener(Event.ADDED,addedHandler);
  71.          param1.addEventListener(Event.REMOVED,removedHandler);
  72.          param1.addEventListener(FlexEvent.SHOW,showHandler);
  73.          param1.addEventListener(FlexEvent.HIDE,hideHandler);
  74.          if(param1.systemManager is SystemManager)
  75.          {
  76.             if(param1 != SystemManager(param1.systemManager).application)
  77.             {
  78.                param1.addEventListener(FlexEvent.CREATION_COMPLETE,creationCompleteHandler);
  79.             }
  80.          }
  81.          param1.systemManager.addFocusManager(param1);
  82.       }
  83.       
  84.       public function deactivate() : void
  85.       {
  86.          mx_internal::form.systemManager.stage.removeEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler);
  87.          mx_internal::form.systemManager.stage.removeEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler);
  88.          mx_internal::form.removeEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  89.          mx_internal::form.removeEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  90.          mx_internal::form.systemManager.stage.removeEventListener(Event.ACTIVATE,activateHandler);
  91.          mx_internal::form.systemManager.stage.removeEventListener(Event.DEACTIVATE,deactivateHandler);
  92.          mx_internal::form.removeEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  93.          mx_internal::form.removeEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  94.          activated = false;
  95.       }
  96.       
  97.       private function getIndexOfNextObject(param1:int, param2:Boolean, param3:Boolean, param4:String) : int
  98.       {
  99.          var _loc7_:DisplayObject = null;
  100.          var _loc8_:IFocusManagerGroup = null;
  101.          var _loc9_:int = 0;
  102.          var _loc10_:DisplayObject = null;
  103.          var _loc11_:IFocusManagerGroup = null;
  104.          var _loc5_:int = focusableCandidates.length;
  105.          var _loc6_:int = param1;
  106.          while(true)
  107.          {
  108.             if(param2)
  109.             {
  110.                param1--;
  111.             }
  112.             else
  113.             {
  114.                param1++;
  115.             }
  116.             if(param3)
  117.             {
  118.                if(param2 && param1 < 0)
  119.                {
  120.                   break;
  121.                }
  122.                if(!param2 && param1 == _loc5_)
  123.                {
  124.                   break;
  125.                }
  126.             }
  127.             else
  128.             {
  129.                param1 = (param1 + _loc5_) % _loc5_;
  130.                if(_loc6_ == param1)
  131.                {
  132.                   break;
  133.                }
  134.             }
  135.             if(isValidFocusCandidate(focusableCandidates[param1],param4))
  136.             {
  137.                if((_loc7_ = DisplayObject(findFocusManagerComponent(focusableCandidates[param1]))) is IFocusManagerGroup)
  138.                {
  139.                   _loc8_ = IFocusManagerGroup(_loc7_);
  140.                   _loc9_ = 0;
  141.                   while(_loc9_ < focusableCandidates.length)
  142.                   {
  143.                      if((_loc10_ = focusableCandidates[_loc9_]) is IFocusManagerGroup)
  144.                      {
  145.                         if((_loc11_ = IFocusManagerGroup(_loc10_)).groupName == _loc8_.groupName && _loc11_.selected)
  146.                         {
  147.                            if(InteractiveObject(_loc10_).tabIndex != InteractiveObject(_loc7_).tabIndex && !_loc8_.selected)
  148.                            {
  149.                               return getIndexOfNextObject(param1,param2,param3,param4);
  150.                            }
  151.                            param1 = _loc9_;
  152.                            break;
  153.                         }
  154.                      }
  155.                      _loc9_++;
  156.                   }
  157.                }
  158.                return param1;
  159.             }
  160.          }
  161.          return param1;
  162.       }
  163.       
  164.       private function mouseFocusChangeHandler(param1:FocusEvent) : void
  165.       {
  166.          var _loc2_:TextField = null;
  167.          if(param1.relatedObject is TextField)
  168.          {
  169.             _loc2_ = param1.relatedObject as TextField;
  170.             if(_loc2_.type == "input" || _loc2_.selectable)
  171.             {
  172.                return;
  173.             }
  174.          }
  175.          param1.preventDefault();
  176.       }
  177.       
  178.       mx_internal function set form(param1:IFocusManagerContainer) : void
  179.       {
  180.          _form = param1;
  181.       }
  182.       
  183.       private function addFocusables(param1:DisplayObject, param2:Boolean = false) : void
  184.       {
  185.          var focusable:IFocusManagerComponent = null;
  186.          var doc:DisplayObjectContainer = null;
  187.          var i:int = 0;
  188.          var rawChildren:IChildList = null;
  189.          var o:DisplayObject = param1;
  190.          var skipTopLevel:Boolean = param2;
  191.          if(o is IFocusManagerComponent && !skipTopLevel)
  192.          {
  193.             focusable = IFocusManagerComponent(o);
  194.             if(focusable.focusEnabled)
  195.             {
  196.                if(focusable.tabEnabled && isTabVisible(o))
  197.                {
  198.                   focusableObjects.push(o);
  199.                   calculateCandidates = true;
  200.                }
  201.                o.addEventListener("tabEnabledChange",tabEnabledChangeHandler);
  202.                o.addEventListener("tabIndexChange",tabIndexChangeHandler);
  203.             }
  204.          }
  205.          if(o is DisplayObjectContainer)
  206.          {
  207.             doc = DisplayObjectContainer(o);
  208.             o.addEventListener("tabChildrenChange",tabChildrenChangeHandler);
  209.             if(doc.tabChildren)
  210.             {
  211.                if(o is IRawChildrenContainer)
  212.                {
  213.                   rawChildren = IRawChildrenContainer(o).rawChildren;
  214.                   i = 0;
  215.                   while(i < rawChildren.numChildren)
  216.                   {
  217.                      try
  218.                      {
  219.                         addFocusables(rawChildren.getChildAt(i));
  220.                      }
  221.                      catch(error:SecurityError)
  222.                      {
  223.                      }
  224.                      i++;
  225.                   }
  226.                }
  227.                else
  228.                {
  229.                   i = 0;
  230.                   while(i < doc.numChildren)
  231.                   {
  232.                      try
  233.                      {
  234.                         addFocusables(doc.getChildAt(i));
  235.                      }
  236.                      catch(error:SecurityError)
  237.                      {
  238.                      }
  239.                      i++;
  240.                   }
  241.                }
  242.             }
  243.          }
  244.       }
  245.       
  246.       private function getMaxTabIndex() : int
  247.       {
  248.          var _loc4_:Number = NaN;
  249.          var _loc1_:Number = 0;
  250.          var _loc2_:int = focusableObjects.length;
  251.          var _loc3_:int = 0;
  252.          while(_loc3_ < _loc2_)
  253.          {
  254.             _loc4_ = focusableObjects[_loc3_].tabIndex;
  255.             if(!isNaN(_loc4_))
  256.             {
  257.                _loc1_ = Math.max(_loc1_,_loc4_);
  258.             }
  259.             _loc3_++;
  260.          }
  261.          return _loc1_;
  262.       }
  263.       
  264.       private function showHandler(param1:Event) : void
  265.       {
  266.          mx_internal::form.systemManager.activate(mx_internal::form);
  267.       }
  268.       
  269.       public function toString() : String
  270.       {
  271.          return Object(mx_internal::form).toString() + ".focusManager";
  272.       }
  273.       
  274.       private function mouseDownHandler(param1:MouseEvent) : void
  275.       {
  276.          if(param1.isDefaultPrevented())
  277.          {
  278.             return;
  279.          }
  280.          var _loc2_:DisplayObject = getTopLevelFocusTarget(InteractiveObject(param1.target));
  281.          if(!_loc2_)
  282.          {
  283.             return;
  284.          }
  285.          showFocusIndicator = false;
  286.          if((_loc2_ != lastFocus || lastAction == "ACTIVATE") && !(_loc2_ is TextField))
  287.          {
  288.             setFocus(IFocusManagerComponent(_loc2_));
  289.          }
  290.          lastAction = "MOUSEDOWN";
  291.       }
  292.       
  293.       private function sortByDepth(param1:IFocusManagerComponent, param2:IFocusManagerComponent) : Number
  294.       {
  295.          var _loc5_:int = 0;
  296.          var _loc6_:String = null;
  297.          var _loc7_:String = null;
  298.          var _loc3_:String = "";
  299.          var _loc4_:String = "";
  300.          var _loc8_:String = "0000";
  301.          var _loc9_:DisplayObject = DisplayObject(param1);
  302.          var _loc10_:DisplayObject = DisplayObject(param2);
  303.          while(_loc9_ != DisplayObject(mx_internal::form) && _loc9_.parent)
  304.          {
  305.             if((_loc6_ = (_loc5_ = getChildIndex(_loc9_.parent,_loc9_)).toString(16)).length < 4)
  306.             {
  307.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  308.             }
  309.             _loc3_ = _loc7_ + _loc3_;
  310.             _loc9_ = _loc9_.parent;
  311.          }
  312.          while(_loc10_ != DisplayObject(mx_internal::form) && _loc10_.parent)
  313.          {
  314.             if((_loc6_ = (_loc5_ = getChildIndex(_loc10_.parent,_loc10_)).toString(16)).length < 4)
  315.             {
  316.                _loc7_ = _loc8_.substring(0,4 - _loc6_.length) + _loc6_;
  317.             }
  318.             _loc4_ = _loc7_ + _loc4_;
  319.             _loc10_ = _loc10_.parent;
  320.          }
  321.          return _loc3_ > _loc4_ ? Number(1) : (_loc3_ < _loc4_ ? Number(-1) : Number(0));
  322.       }
  323.       
  324.       private function focusOutHandler(param1:FocusEvent) : void
  325.       {
  326.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  327.       }
  328.       
  329.       public function setFocus(param1:IFocusManagerComponent) : void
  330.       {
  331.          param1.setFocus();
  332.       }
  333.       
  334.       private function getChildIndex(param1:DisplayObjectContainer, param2:DisplayObject) : int
  335.       {
  336.          var parent:DisplayObjectContainer = param1;
  337.          var child:DisplayObject = param2;
  338.          try
  339.          {
  340.             return parent.getChildIndex(child);
  341.          }
  342.          catch(e:Error)
  343.          {
  344.             if(parent is IRawChildrenContainer)
  345.             {
  346.                return IRawChildrenContainer(parent).rawChildren.getChildIndex(child);
  347.             }
  348.             throw e;
  349.          }
  350.       }
  351.       
  352.       public function findFocusManagerComponent(param1:InteractiveObject) : IFocusManagerComponent
  353.       {
  354.          while(param1)
  355.          {
  356.             if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled)
  357.             {
  358.                return IFocusManagerComponent(param1);
  359.             }
  360.             param1 = param1.parent;
  361.          }
  362.          return null;
  363.       }
  364.       
  365.       private function sortFocusableObjectsTabIndex() : void
  366.       {
  367.          var _loc3_:IFocusManagerComponent = null;
  368.          focusableCandidates = [];
  369.          var _loc1_:int = focusableObjects.length;
  370.          var _loc2_:int = 0;
  371.          while(_loc2_ < _loc1_)
  372.          {
  373.             _loc3_ = focusableObjects[_loc2_];
  374.             if(_loc3_.tabIndex && !isNaN(Number(_loc3_.tabIndex)))
  375.             {
  376.                focusableCandidates.push(_loc3_);
  377.             }
  378.             _loc2_++;
  379.          }
  380.          focusableCandidates.sort(sortByTabIndex);
  381.       }
  382.       
  383.       private function removeFocusables(param1:DisplayObject, param2:Boolean) : void
  384.       {
  385.          var _loc3_:int = 0;
  386.          if(param1 is DisplayObjectContainer)
  387.          {
  388.             if(!param2)
  389.             {
  390.                param1.removeEventListener("tabChildrenChange",tabChildrenChangeHandler);
  391.             }
  392.             _loc3_ = 0;
  393.             while(_loc3_ < focusableObjects.length)
  394.             {
  395.                if(isParent(DisplayObjectContainer(param1),focusableObjects[_loc3_]))
  396.                {
  397.                   if(focusableObjects[_loc3_] == lastFocus)
  398.                   {
  399.                      lastFocus.drawFocus(false);
  400.                      lastFocus = null;
  401.                   }
  402.                   focusableObjects[_loc3_].removeEventListener("tabEnabledChange",tabEnabledChangeHandler);
  403.                   focusableObjects[_loc3_].removeEventListener("tabIndexChange",tabIndexChangeHandler);
  404.                   focusableObjects.splice(_loc3_,1);
  405.                   _loc3_--;
  406.                   calculateCandidates = true;
  407.                }
  408.                _loc3_++;
  409.             }
  410.          }
  411.       }
  412.       
  413.       private function setFocusToNextObject(param1:FocusEvent) : void
  414.       {
  415.          if(focusableObjects.length == 0)
  416.          {
  417.             return;
  418.          }
  419.          var _loc2_:IFocusManagerComponent = getNextFocusManagerComponent(param1.shiftKey);
  420.          if(_loc2_)
  421.          {
  422.             if(_loc2_ is IFocusManagerComplexComponent)
  423.             {
  424.                IFocusManagerComplexComponent(_loc2_).assignFocus(!!param1.shiftKey ? "bottom" : "top");
  425.             }
  426.             else
  427.             {
  428.                setFocus(_loc2_);
  429.             }
  430.          }
  431.       }
  432.       
  433.       private function getTopLevelFocusTarget(param1:InteractiveObject) : InteractiveObject
  434.       {
  435.          while(param1 != InteractiveObject(mx_internal::form))
  436.          {
  437.             if(param1 is IFocusManagerComponent && IFocusManagerComponent(param1).focusEnabled && IFocusManagerComponent(param1).mouseFocusEnabled && (param1 is IUIComponent ? Boolean(IUIComponent(param1).enabled) : Boolean(true)))
  438.             {
  439.                return param1;
  440.             }
  441.             param1 = param1.parent;
  442.             if(param1 == null)
  443.             {
  444.                break;
  445.             }
  446.          }
  447.          return null;
  448.       }
  449.       
  450.       public function set defaultButton(param1:IButton) : void
  451.       {
  452.          var _loc2_:IButton = !!param1 ? IButton(param1) : null;
  453.          if(_loc2_ != _defaultButton)
  454.          {
  455.             if(_defaultButton)
  456.             {
  457.                _defaultButton.emphasized = false;
  458.             }
  459.             if(defButton)
  460.             {
  461.                defButton.emphasized = false;
  462.             }
  463.             _defaultButton = _loc2_;
  464.             defButton = _loc2_;
  465.             if(_loc2_)
  466.             {
  467.                _loc2_.emphasized = true;
  468.             }
  469.          }
  470.       }
  471.       
  472.       mx_internal function sendDefaultButtonEvent() : void
  473.       {
  474.          defButton.dispatchEvent(new MouseEvent("click"));
  475.       }
  476.       
  477.       public function getFocus() : IFocusManagerComponent
  478.       {
  479.          var _loc1_:InteractiveObject = mx_internal::form.systemManager.stage.focus;
  480.          return findFocusManagerComponent(_loc1_);
  481.       }
  482.       
  483.       private function isEnabledAndVisible(param1:DisplayObject) : Boolean
  484.       {
  485.          var _loc2_:DisplayObjectContainer = DisplayObject(mx_internal::form).parent;
  486.          while(param1 != _loc2_)
  487.          {
  488.             if(param1 is IUIComponent)
  489.             {
  490.                if(!IUIComponent(param1).enabled)
  491.                {
  492.                   return false;
  493.                }
  494.             }
  495.             if(!param1.visible)
  496.             {
  497.                return false;
  498.             }
  499.             param1 = param1.parent;
  500.          }
  501.          return true;
  502.       }
  503.       
  504.       private function deactivateHandler(param1:Event) : void
  505.       {
  506.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  507.       }
  508.       
  509.       private function hideHandler(param1:Event) : void
  510.       {
  511.          mx_internal::form.systemManager.deactivate(mx_internal::form);
  512.       }
  513.       
  514.       private function addedHandler(param1:Event) : void
  515.       {
  516.          var _loc2_:DisplayObject = DisplayObject(param1.target);
  517.          if(_loc2_.stage)
  518.          {
  519.             addFocusables(DisplayObject(param1.target));
  520.          }
  521.       }
  522.       
  523.       public function hideFocus() : void
  524.       {
  525.          if(showFocusIndicator)
  526.          {
  527.             showFocusIndicator = false;
  528.             if(lastFocus)
  529.             {
  530.                lastFocus.drawFocus(false);
  531.             }
  532.          }
  533.       }
  534.       
  535.       private function tabChildrenChangeHandler(param1:Event) : void
  536.       {
  537.          if(param1.target != param1.currentTarget)
  538.          {
  539.             return;
  540.          }
  541.          calculateCandidates = true;
  542.          var _loc2_:DisplayObjectContainer = DisplayObjectContainer(param1.target);
  543.          if(_loc2_.tabChildren)
  544.          {
  545.             addFocusables(_loc2_,true);
  546.          }
  547.          else
  548.          {
  549.             removeFocusables(_loc2_,true);
  550.          }
  551.       }
  552.       
  553.       private function isValidFocusCandidate(param1:DisplayObject, param2:String) : Boolean
  554.       {
  555.          var _loc3_:IFocusManagerGroup = null;
  556.          if(!isEnabledAndVisible(param1))
  557.          {
  558.             return false;
  559.          }
  560.          if(param1 is IFocusManagerGroup)
  561.          {
  562.             _loc3_ = IFocusManagerGroup(param1);
  563.             if(param2 == _loc3_.groupName)
  564.             {
  565.                return false;
  566.             }
  567.          }
  568.          return true;
  569.       }
  570.       
  571.       public function set focusPane(param1:Sprite) : void
  572.       {
  573.          _focusPane = param1;
  574.       }
  575.       
  576.       private function keyFocusChangeHandler(param1:FocusEvent) : void
  577.       {
  578.          showFocusIndicator = true;
  579.          if(param1.keyCode == Keyboard.TAB && !param1.isDefaultPrevented())
  580.          {
  581.             if(browserFocusComponent)
  582.             {
  583.                if(browserFocusComponent.tabIndex == LARGE_TAB_INDEX)
  584.                {
  585.                   browserFocusComponent.tabIndex = -1;
  586.                }
  587.                browserFocusComponent = null;
  588.                return;
  589.             }
  590.             setFocusToNextObject(param1);
  591.             param1.preventDefault();
  592.          }
  593.       }
  594.       
  595.       private function getIndexOfFocusedObject(param1:DisplayObject) : int
  596.       {
  597.          var _loc4_:IUIComponent = null;
  598.          if(!param1)
  599.          {
  600.             return -1;
  601.          }
  602.          var _loc2_:int = focusableCandidates.length;
  603.          var _loc3_:int = 0;
  604.          _loc3_ = 0;
  605.          while(_loc3_ < _loc2_)
  606.          {
  607.             if(focusableCandidates[_loc3_] == param1)
  608.             {
  609.                return _loc3_;
  610.             }
  611.             _loc3_++;
  612.          }
  613.          _loc3_ = 0;
  614.          while(_loc3_ < _loc2_)
  615.          {
  616.             if((_loc4_ = focusableCandidates[_loc3_] as IUIComponent) && _loc4_.owns(param1))
  617.             {
  618.                return _loc3_;
  619.             }
  620.             _loc3_++;
  621.          }
  622.          return -1;
  623.       }
  624.       
  625.       private function isParent(param1:DisplayObjectContainer, param2:DisplayObject) : Boolean
  626.       {
  627.          if(param1 is IRawChildrenContainer)
  628.          {
  629.             return IRawChildrenContainer(param1).rawChildren.contains(param2);
  630.          }
  631.          return param1.contains(param2);
  632.       }
  633.       
  634.       private function removedHandler(param1:Event) : void
  635.       {
  636.          var _loc2_:int = 0;
  637.          var _loc3_:DisplayObject = DisplayObject(param1.target);
  638.          if(_loc3_ is IFocusManagerComponent)
  639.          {
  640.             _loc2_ = 0;
  641.             while(_loc2_ < focusableObjects.length)
  642.             {
  643.                if(_loc3_ == focusableObjects[_loc2_])
  644.                {
  645.                   if(_loc3_ == lastFocus)
  646.                   {
  647.                      lastFocus.drawFocus(false);
  648.                      lastFocus = null;
  649.                   }
  650.                   _loc3_.removeEventListener("tabEnabledChange",tabEnabledChangeHandler);
  651.                   _loc3_.removeEventListener("tabIndexChange",tabIndexChangeHandler);
  652.                   focusableObjects.splice(_loc2_,1);
  653.                   calculateCandidates = true;
  654.                   break;
  655.                }
  656.                _loc2_++;
  657.             }
  658.          }
  659.          removeFocusables(_loc3_,false);
  660.       }
  661.       
  662.       mx_internal function get form() : IFocusManagerContainer
  663.       {
  664.          return _form;
  665.       }
  666.       
  667.       private function tabIndexChangeHandler(param1:Event) : void
  668.       {
  669.          calculateCandidates = true;
  670.       }
  671.       
  672.       private function sortFocusableObjects() : void
  673.       {
  674.          var _loc3_:InteractiveObject = null;
  675.          focusableCandidates = [];
  676.          var _loc1_:int = focusableObjects.length;
  677.          var _loc2_:int = 0;
  678.          while(_loc2_ < _loc1_)
  679.          {
  680.             _loc3_ = focusableObjects[_loc2_];
  681.             if(_loc3_.tabIndex && !isNaN(Number(_loc3_.tabIndex)) && _loc3_.tabIndex > 0)
  682.             {
  683.                sortFocusableObjectsTabIndex();
  684.                return;
  685.             }
  686.             focusableCandidates.push(_loc3_);
  687.             _loc2_++;
  688.          }
  689.          focusableCandidates.sort(sortByDepth);
  690.       }
  691.       
  692.       public function get nextTabIndex() : int
  693.       {
  694.          return getMaxTabIndex() + 1;
  695.       }
  696.       
  697.       public function get defaultButton() : IButton
  698.       {
  699.          return _defaultButton;
  700.       }
  701.       
  702.       public function showFocus() : void
  703.       {
  704.          if(!showFocusIndicator)
  705.          {
  706.             showFocusIndicator = true;
  707.             if(lastFocus)
  708.             {
  709.                lastFocus.drawFocus(true);
  710.             }
  711.          }
  712.       }
  713.       
  714.       private function activateHandler(param1:Event) : void
  715.       {
  716.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  717.          if(lastFocus && !browserMode)
  718.          {
  719.             lastFocus.setFocus();
  720.          }
  721.          lastAction = "ACTIVATE";
  722.       }
  723.       
  724.       public function getNextFocusManagerComponent(param1:Boolean = false) : IFocusManagerComponent
  725.       {
  726.          var _loc8_:IFocusManagerGroup = null;
  727.          if(focusableObjects.length == 0)
  728.          {
  729.             return null;
  730.          }
  731.          if(calculateCandidates)
  732.          {
  733.             sortFocusableObjects();
  734.             calculateCandidates = false;
  735.          }
  736.          var _loc2_:DisplayObject = mx_internal::form.systemManager.stage.focus;
  737.          _loc2_ = DisplayObject(findFocusManagerComponent(InteractiveObject(_loc2_)));
  738.          var _loc3_:String = "";
  739.          if(_loc2_ is IFocusManagerGroup)
  740.          {
  741.             _loc3_ = (_loc8_ = IFocusManagerGroup(_loc2_)).groupName;
  742.          }
  743.          var _loc4_:int = getIndexOfFocusedObject(_loc2_);
  744.          var _loc5_:Boolean = false;
  745.          var _loc6_:int = _loc4_;
  746.          if(_loc4_ == -1)
  747.          {
  748.             if(param1)
  749.             {
  750.                _loc4_ = focusableCandidates.length;
  751.             }
  752.             _loc5_ = true;
  753.          }
  754.          var _loc7_:int = getIndexOfNextObject(_loc4_,param1,_loc5_,_loc3_);
  755.          return findFocusManagerComponent(focusableCandidates[_loc7_]);
  756.       }
  757.       
  758.       public function get focusPane() : Sprite
  759.       {
  760.          return _focusPane;
  761.       }
  762.       
  763.       public function set defaultButtonEnabled(param1:Boolean) : void
  764.       {
  765.          _defaultButtonEnabled = param1;
  766.       }
  767.       
  768.       private function keyDownHandler(param1:KeyboardEvent) : void
  769.       {
  770.          var _loc3_:DisplayObject = null;
  771.          var _loc4_:String = null;
  772.          var _loc5_:int = 0;
  773.          var _loc6_:int = 0;
  774.          var _loc7_:IFocusManagerGroup = null;
  775.          var _loc2_:SystemManager = mx_internal::form.systemManager as SystemManager;
  776.          if(_loc2_)
  777.          {
  778.             _loc2_.idleCounter = 0;
  779.          }
  780.          if(param1.keyCode == Keyboard.TAB)
  781.          {
  782.             lastAction = "KEY";
  783.             if(calculateCandidates)
  784.             {
  785.                sortFocusableObjects();
  786.                calculateCandidates = false;
  787.             }
  788.          }
  789.          if(browserMode)
  790.          {
  791.             if(param1.keyCode == Keyboard.TAB && focusableCandidates.length > 0)
  792.             {
  793.                _loc3_ = mx_internal::form.systemManager.stage.focus;
  794.                _loc3_ = DisplayObject(findFocusManagerComponent(InteractiveObject(_loc3_)));
  795.                _loc4_ = "";
  796.                if(_loc3_ is IFocusManagerGroup)
  797.                {
  798.                   _loc4_ = (_loc7_ = IFocusManagerGroup(_loc3_)).groupName;
  799.                }
  800.                _loc5_ = getIndexOfFocusedObject(_loc3_);
  801.                _loc6_ = getIndexOfNextObject(_loc5_,param1.shiftKey,false,_loc4_);
  802.                if(param1.shiftKey)
  803.                {
  804.                   if(_loc6_ >= _loc5_)
  805.                   {
  806.                      browserFocusComponent = mx_internal::form.systemManager.stage.focus;
  807.                      if(browserFocusComponent.tabIndex == -1)
  808.                      {
  809.                         browserFocusComponent.tabIndex = 0;
  810.                      }
  811.                   }
  812.                }
  813.                else if(_loc6_ <= _loc5_)
  814.                {
  815.                   browserFocusComponent = mx_internal::form.systemManager.stage.focus;
  816.                   if(browserFocusComponent.tabIndex == -1)
  817.                   {
  818.                      browserFocusComponent.tabIndex = LARGE_TAB_INDEX;
  819.                   }
  820.                }
  821.             }
  822.          }
  823.          if(defaultButtonEnabled && param1.keyCode == Keyboard.ENTER && defaultButton && defButton.enabled)
  824.          {
  825.             defButton.callLater(mx_internal::sendDefaultButtonEvent);
  826.          }
  827.       }
  828.       
  829.       private function focusInHandler(param1:FocusEvent) : void
  830.       {
  831.          var _loc3_:IButton = null;
  832.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  833.          if(isParent(DisplayObjectContainer(mx_internal::form),_loc2_))
  834.          {
  835.             lastFocus = findFocusManagerComponent(InteractiveObject(_loc2_));
  836.             if(lastFocus is IButton)
  837.             {
  838.                _loc3_ = lastFocus as IButton;
  839.                if(defButton)
  840.                {
  841.                   defButton.emphasized = false;
  842.                   defButton = _loc3_;
  843.                   _loc3_.emphasized = true;
  844.                }
  845.             }
  846.             else if(defButton && defButton != _defaultButton)
  847.             {
  848.                defButton.emphasized = false;
  849.                defButton = _defaultButton;
  850.                _defaultButton.emphasized = true;
  851.             }
  852.          }
  853.       }
  854.       
  855.       public function set showFocusIndicator(param1:Boolean) : void
  856.       {
  857.          _showFocusIndicator = param1;
  858.       }
  859.       
  860.       private function sortByTabIndex(param1:IFocusManagerComponent, param2:IFocusManagerComponent) : int
  861.       {
  862.          var _loc3_:int = param1.tabIndex;
  863.          var _loc4_:int = param2.tabIndex;
  864.          if(_loc3_ == -1)
  865.          {
  866.             _loc3_ = int.MAX_VALUE;
  867.          }
  868.          if(_loc4_ == -1)
  869.          {
  870.             _loc4_ = int.MAX_VALUE;
  871.          }
  872.          return _loc3_ > _loc4_ ? 1 : (_loc3_ < _loc4_ ? -1 : int(sortByDepth(param1,param2)));
  873.       }
  874.       
  875.       public function activate() : void
  876.       {
  877.          if(activated)
  878.          {
  879.             return;
  880.          }
  881.          mx_internal::form.systemManager.stage.addEventListener(FocusEvent.MOUSE_FOCUS_CHANGE,mouseFocusChangeHandler,false,0,true);
  882.          mx_internal::form.systemManager.stage.addEventListener(FocusEvent.KEY_FOCUS_CHANGE,keyFocusChangeHandler,false,0,true);
  883.          mx_internal::form.addEventListener(FocusEvent.FOCUS_IN,focusInHandler,true);
  884.          mx_internal::form.addEventListener(FocusEvent.FOCUS_OUT,focusOutHandler,true);
  885.          mx_internal::form.systemManager.stage.addEventListener(Event.ACTIVATE,activateHandler,false,0,true);
  886.          mx_internal::form.systemManager.stage.addEventListener(Event.DEACTIVATE,deactivateHandler,false,0,true);
  887.          mx_internal::form.addEventListener(MouseEvent.MOUSE_DOWN,mouseDownHandler);
  888.          mx_internal::form.addEventListener(KeyboardEvent.KEY_DOWN,keyDownHandler,true);
  889.          activated = true;
  890.          if(lastFocus)
  891.          {
  892.             setFocus(lastFocus);
  893.          }
  894.       }
  895.       
  896.       public function get defaultButtonEnabled() : Boolean
  897.       {
  898.          return _defaultButtonEnabled;
  899.       }
  900.       
  901.       private function isTabVisible(param1:DisplayObject) : Boolean
  902.       {
  903.          var _loc2_:DisplayObject = DisplayObject(mx_internal::form.systemManager);
  904.          if(!_loc2_)
  905.          {
  906.             return false;
  907.          }
  908.          var _loc3_:DisplayObjectContainer = param1.parent;
  909.          while(_loc3_ && _loc3_ != _loc2_)
  910.          {
  911.             if(!_loc3_.tabChildren)
  912.             {
  913.                return false;
  914.             }
  915.             _loc3_ = _loc3_.parent;
  916.          }
  917.          return true;
  918.       }
  919.       
  920.       private function creationCompleteHandler(param1:FlexEvent) : void
  921.       {
  922.          if(DisplayObject(mx_internal::form).visible && !activated)
  923.          {
  924.             mx_internal::form.systemManager.activate(mx_internal::form);
  925.          }
  926.       }
  927.       
  928.       public function get showFocusIndicator() : Boolean
  929.       {
  930.          return _showFocusIndicator;
  931.       }
  932.       
  933.       private function tabEnabledChangeHandler(param1:Event) : void
  934.       {
  935.          calculateCandidates = true;
  936.          var _loc2_:InteractiveObject = InteractiveObject(param1.target);
  937.          var _loc3_:int = focusableObjects.length;
  938.          var _loc4_:int = 0;
  939.          while(_loc4_ < _loc3_)
  940.          {
  941.             if(focusableObjects[_loc4_] == _loc2_)
  942.             {
  943.                break;
  944.             }
  945.             _loc4_++;
  946.          }
  947.          if(_loc2_.tabEnabled)
  948.          {
  949.             if(_loc4_ == _loc3_ && isTabVisible(_loc2_))
  950.             {
  951.                focusableObjects.push(_loc2_);
  952.             }
  953.          }
  954.          else if(_loc4_ < _loc3_)
  955.          {
  956.             focusableObjects.splice(_loc4_,1);
  957.          }
  958.       }
  959.    }
  960. }
  961.